```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Spring Boot自定义Starter指南 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #6e8efb 0%, #4a6cf7 100%);
        }
        .heading-font {
            font-family: 'Noto Serif SC', serif;
        }
        .code-block {
            background-color: #282c34;
            border-radius: 8px;
            padding: 1.5rem;
            position: relative;
        }
        .code-block pre {
            margin: 0;
            overflow-x: auto;
        }
        .code-block .lang {
            position: absolute;
            top: 0;
            right: 0;
            background: rgba(255,255,255,0.1);
            color: white;
            padding: 0.25rem 0.75rem;
            border-bottom-left-radius: 8px;
            font-size: 0.8rem;
        }
        .card {
            transition: all 0.3s ease;
            border-radius: 12px;
            overflow: hidden;
            box-shadow: 0 4px 6px rgba(0,0,0,0.05);
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px rgba(0,0,0,0.1);
        }
        .card-img {
            height: 200px;
            object-fit: cover;
            object-position: center;
        }
        .divider {
            position: relative;
            height: 1px;
            background: linear-gradient(90deg, transparent 0%, rgba(0,0,0,0.1) 50%, transparent 100%);
        }
        .divider:before {
            content: "◆";
            position: absolute;
            left: 50%;
            top: -10px;
            transform: translateX(-50%);
            background: white;
            padding: 0 10px;
            color: #4a6cf7;
        }
        .section-icon {
            width: 48px;
            height: 48px;
            background: linear-gradient(135deg, #4a6cf7 0%, #6e8efb 100%);
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            color: white;
            margin-right: 1rem;
            flex-shrink: 0;
        }
        .feature-item {
            transition: all 0.3s ease;
        }
        .feature-item:hover {
            background-color: rgba(74, 108, 247, 0.05);
            transform: translateX(5px);
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20">
        <div class="container mx-auto px-6 max-w-5xl">
            <div class="flex flex-col items-center text-center">
                <span class="bg-white bg-opacity-20 rounded-full px-4 py-1 mb-4 text-sm font-medium">Spring Boot进阶</span>
                <h1 class="heading-font text-4xl md:text-5xl font-bold mb-6 leading-tight">Spring Boot中如何自定义Starter</h1>
                <p class="text-xl opacity-90 max-w-3xl mb-8">掌握模块化开发的利器，打造企业级可复用组件</p>
                <div class="flex space-x-4">
                    <a href="#concept" class="bg-white text-blue-600 font-medium px-6 py-3 rounded-full hover:bg-opacity-90 transition">开始阅读</a>
                    <a href="#demo" class="border border-white border-opacity-40 text-white font-medium px-6 py-3 rounded-full hover:bg-white hover:bg-opacity-10 transition">查看示例</a>
                </div>
            </div>
        </div>
    </section>

    <!-- Content Section -->
    <div class="container mx-auto px-6 py-16 max-w-5xl">
        <!-- Introduction -->
        <section class="mb-20">
            <p class="text-lg mb-6 text-gray-700">
                在开发企业级应用时，随着系统功能的扩展和模块化需求的增加，我们通常需要重用多个项目中的相同组件和功能。这时，如何将常用的业务逻辑、配置和依赖封装成一个独立的模块，并且在不同的项目中自动加载和配置，便成为了一个关键问题。Spring Boot 为我们提供了一个极具灵活性的解决方案——<strong>Starter机制</strong>。
            </p>
            <div class="my-8 rounded-xl overflow-hidden shadow-lg">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1727755915186-1402b149-ba02-449d-938c-8f36bf648e9a.png" alt="Spring Boot Starter概览" class="w-full h-auto">
            </div>
            <p class="text-lg text-gray-700">
                Spring Boot Starter 是一种特性，它允许开发者将特定功能的配置、依赖和逻辑打包成一个独立的模块，方便在多个项目中直接使用。Spring Boot 自身就提供了多种内置 Starter，比如<code class="bg-gray-100 px-2 py-1 rounded">spring-boot-starter-web</code>用于Web应用的开发，<code class="bg-gray-100 px-2 py-1 rounded">spring-boot-starter-data-jpa</code>用于与数据库的交互。但是，有时候内置的 Starter 并不能完全满足我们项目的需求。假如我们的系统需要特定的日志格式、定制化的数据库连接池管理，甚至一些特有的业务逻辑，我们就可以通过自定义 Starter 来实现这些特性。
            </p>
        </section>

        <!-- Concept Section -->
        <section id="concept" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="section-icon">
                    <i class="fas fa-lightbulb text-xl"></i>
                </div>
                <h2 class="heading-font text-3xl font-bold">概念和作用</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div class="card bg-white p-6">
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">1. 概念介绍</h3>
                    <p class="text-gray-700 mb-4">
                        Spring Boot Starter 是 Spring Boot 提供的一个模块化设计概念，旨在简化项目开发过程中第三方库的引入和配置。Starter 本质上是一个 Maven 或 Gradle 依赖，它将特定功能所需的所有依赖项、默认配置和自动化机制封装在一起。
                    </p>
                    <p class="text-gray-700">
                        通过使用 Starter，开发者可以快速集成特定的技术栈，而无需手动配置繁琐的依赖和设置。例如，<code class="bg-gray-100 px-1 py-0.5 rounded">spring-boot-starter-web</code> 将 Spring MVC、Tomcat 以及相关依赖打包在一起，允许开发者通过简单的依赖引入，快速创建 Web 应用。
                    </p>
                    <div class="mt-6 rounded overflow-hidden">
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1727755948627-ccac6406-271c-4f6a-bae2-4e55e1497cc9.png" alt="Starter概念图" class="w-full h-auto">
                    </div>
                </div>
                
                <div class="card bg-white p-6">
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">2. 作用和优势</h3>
                    <div class="space-y-4">
                        <div class="feature-item p-4 rounded-lg">
                            <h4 class="font-bold text-gray-800 flex items-center">
                                <i class="fas fa-cubes text-blue-500 mr-2"></i>
                                <span>简化依赖管理</span>
                            </h4>
                            <p class="text-gray-700 mt-2">
                                传统的 Java 项目通常需要手动引入多个依赖项，并且在不同技术栈之间需要配置相互依赖的库。而 Starter 将常见功能模块化，打包了预配置的依赖项，开发者只需在 Maven 或 Gradle 文件中引入一个 Starter 依赖，就可以拥有完整的功能集成。
                            </p>
                        </div>
                        <div class="feature-item p-4 rounded-lg">
                            <h4 class="font-bold text-gray-800 flex items-center">
                                <i class="fas fa-magic text-blue-500 mr-2"></i>
                                <span>提供开箱即用的自动配置</span>
                            </h4>
                            <p class="text-gray-700 mt-2">
                                Starter 通常与 Spring Boot 的自动配置功能紧密结合。通过自动配置，Spring Boot 根据当前的依赖和环境变量，自动推断并装配应用所需的Bean。例如，当引入<code class="bg-gray-100 px-1 py-0.5 rounded">spring-boot-starter-data-jpa</code>后，Spring Boot会自动配置JPA相关的Bean。
                            </p>
                        </div>
                        <div class="feature-item p-4 rounded-lg">
                            <h4 class="font-bold text-gray-800 flex items-center">
                                <i class="fas fa-project-diagram text-blue-500 mr-2"></i>
                                <span>标准化和模块化开发</span>
                            </h4>
                            <p class="text-gray-700 mt-2">
                                通过将应用的常用功能封装成 Starter，开发者可以实现代码和功能的重用。这样不仅提高了代码的复用性，还能确保多个项目中相同的功能模块一致性，降低维护成本。
                            </p>
                        </div>
                    </div>
                </div>
            </div>

            <div class="card bg-white p-6">
                <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">3. 应用场景</h3>
                <p class="text-gray-700 mb-4">
                    Spring Boot Starter 广泛应用于各种应用场景，包括：
                </p>
                <div class="grid sm:grid-cols-2 md:grid-cols-4 gap-4">
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <i class="fas fa-globe text-blue-500 text-2xl mb-2"></i>
                        <h4 class="font-semibold">Web 应用开发</h4>
                        <p class="text-sm text-gray-600">spring-boot-starter-web 提供了创建 RESTful Web 服务的所有必要组件</p>
                    </div>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <i class="fas fa-database text-blue-500 text-2xl mb-2"></i>
                        <h4 class="font-semibold">数据访问</h4>
                        <p class="text-sm text-gray-600">通过spring-boot-starter-data-jpa，开发者可以方便地与数据库进行交互</p>
                    </div>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <i class="fas fa-lock text-blue-500 text-2xl mb-2"></i>
                        <h4 class="font-semibold">安全性</h4>
                        <p class="text-sm text-gray-600">spring-boot-starter-security 提供了一整套安全认证和授权机制</p>
                    </div>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <i class="fas fa-envelope text-blue-500 text-2xl mb-2"></i>
                        <h4 class="font-semibold">消息队列</h4>
                        <p class="text-sm text-gray-600">spring-boot-starter-amqp 可以轻松集成 RabbitMQ</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Core Dependency Section -->
        <section id="core" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="section-icon">
                    <i class="fas fa-cogs text-xl"></i>
                </div>
                <h2 class="heading-font text-3xl font-bold">创建核心依赖</h2>
            </div>
            
            <div class="card bg-white p-6 mb-8">
                <p class="text-gray-700 mb-6">
                    在<strong>自定义 Spring Boot Starter</strong> 时，创建核心依赖是一个重要的步骤，它能够帮助我们将通用功能模块打包成独立的库，便于项目中进行引入和复用。在此过程中，核心依赖主要包括：<strong>自动配置类</strong>、<strong>Starter 模块的依赖管理</strong>以及与业务逻辑相关的组件。这一部分的设计必须考虑到模块的可插拔性和高扩展性，确保 Starter 能够在不同项目中轻松集成。
                </p>
                <div class="my-6 rounded-xl overflow-hidden">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1727756134818-0254ad79-96cd-4f27-9239-8edd0af9a776.png" alt="核心依赖结构" class="w-full h-auto">
                </div>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div class="card bg-white p-6">
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">1. 确定核心依赖的作用</h3>
                    <p class="text-gray-700 mb-4">
                        在自定义 Starter 时，核心依赖通常指 Starter 模块所依赖的库、自动配置的 Bean 以及需要启动时加载的类。它的作用主要是：
                    </p>
                    <ul class="text-gray-700 space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                            <span>提供通用功能模块，避免重复开发</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                            <span>实现自动配置，简化开发人员的配置过程</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-blue-500 mr-2 mt-1"></i>
                            <span>提供必要的依赖管理，确保项目使用正确的版本</span>
                        </li>
                    </ul>
                    <p class="text-gray-700">
                        例如，一个自定义日志 Starter，核心依赖可能包括日志库依赖（如 Logback 或 Log4j2）、配置自动化（通过 Spring Boot 的自动配置机制，提供默认配置）以及工具类和服务类（如自定义的日志拦截器或格式化器）。
                    </p>
                </div>

                <div class="card bg-white p-6">
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">2. 创建 starter-core 模块</h3>
                    <p class="text-gray-700 mb-4">
                        在构建 Starter 时，通常会为 Starter 的核心逻辑创建一个单独的模块，称为 <code class="bg-gray-100 px-1 py-0.5 rounded">starter-core</code> 模块。该模块包含核心的功能逻辑。
                    </p>
                    <div class="mb-4">
                        <h4 class="font-semibold text-gray-800 mb-2 flex items-center">
                            <i class="fas fa-code-branch text-blue-500 mr-2"></i>
                            依赖管理
                        </h4>
                        <div class="code-block">
                            <span class="lang">XML</span>
                            <pre class="text-gray-200"><code>&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter&lt;/artifactId&gt;
&lt;/dependency&gt;

&lt;dependency&gt;
    &lt;groupId&gt;com.example.logging&lt;/groupId&gt;
    &lt;artifactId&gt;custom-logging-lib&lt;/artifactId&gt;
    &lt;version&gt;1.0.0&lt;/version&gt;
&lt;/dependency&gt;</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Auto Configuration Section -->
        <section id="auto-config" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="section-icon">
                    <i class="fas fa-robot text-xl"></i>
                </div>
                <h2 class="heading-font text-3xl font-bold">实现自动装配</h2>
            </div>
            
            <div class="card bg-white p-6 mb-8">
                <p class="text-gray-700 mb-6">
                    在 Spring Boot 自定义 Starter 中，实现<strong>自动装配</strong>（Auto-Configuration）是核心环节之一，它能够让 Starter 模块在引入时自动注册必要的 Bean，而无需手动配置。自动装配通过 Spring Boot 的自动配置机制实现，即在条件满足时，自动创建并注入特定的 Bean。这一机制大大简化了应用程序的开发和配置，尤其是在处理通用功能时，比如日志、缓存、消息队列等。
                </p>
            </div>

            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div>
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">自动装配的工作原理</h3>
                    <p class="text-gray-700 mb-4">
                        Spring Boot 的自动装配依赖于以下几个关键机制：
                    </p>
                    <ul class="text-gray-700 space-y-2 mb-4">
                        <li class="flex items-start">
                            <i class="fas fa-code text-blue-500 mr-2 mt-1"></i>
                            <span><code>@Configuration</code>注解：用于定义一个配置类，该类包含需要注册为 Spring 容器管理的 Bean</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-code text-blue-500 mr-2 mt-1"></i>
                            <span><code>@Conditional</code>系列注解：用于条件性地加载 Bean，只有在某些条件满足时，才会自动装配指定的 Bean</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-code text-blue-500 mr-2 mt-1"></i>
                            <span><code>spring.factories</code>文件：该文件用于声明自动配置类，它告诉 Spring Boot 哪些自动配置类应该被加载</span>
                        </li>
                    </ul>
                </div>
                <div>
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">自动配置类示例</h3>
                    <div class="code-block">
                        <span class="lang">Java</span>
                        <pre class="text-gray-200"><code>@Configuration
@ConditionalOnClass(CustomService.class)
@EnableConfigurationProperties(CustomServiceProperties.class)
public class CustomServiceAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public CustomService customService(CustomServiceProperties properties) {
        return new CustomService(properties.getServiceUrl());
    }
}</code></pre>
                    </div>
                </div>
            </div>

            <div class="card bg-white p-6">
                <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">spring.factories 配置</h3>
                <p class="text-gray-700 mb-4">
                    为了让 Spring Boot 知道应该加载哪些自动配置类，我们需要在 <code class="bg-gray-100 px-1 py-0.5 rounded">src/main/resources/META-INF/spring.factories</code> 文件中进行声明。
                </p>
                <div class="code-block mb-6">
                    <span class="lang">Properties</span>
                    <pre class="text-gray-200"><code>org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.demo.config.CustomServiceAutoConfiguration</code></pre>
                </div>
                <p class="text-gray-700">
                    <code>EnableAutoConfiguration</code>：Spring Boot 在启动时会扫描 <code>spring.factories</code> 文件中列出的配置类，并根据条件判断是否需要将这些类中的 Bean 注册到 Spring 容器中。
                </p>
            </div>
        </section>

        <!-- Properties Section -->
        <section id="properties" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="section-icon">
                    <i class="fas fa-sliders-h text-xl"></i>
                </div>
                <h2 class="heading-font text-3xl font-bold">编写自定义配置属性</h2>
            </div>
            
            <div class="card bg-white p-6 mb-8">
                <p class="text-gray-700">
                    在 Spring Boot 中编写自定义配置属性是实现自动化配置的核心之一。自定义配置属性可以让用户通过外部化配置（如 <code class="bg-gray-100 px-1 py-0.5 rounded">application.properties</code> 或 <code class="bg-gray-100 px-1 py-0.5 rounded">application.yml</code>）来动态调整 Starter 中的功能，从而增强可配置性和灵活性。
                </p>
            </div>

            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div>
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">配置属性类</h3>
                    <div class="code-block">
                        <span class="lang">Java</span>
                        <pre class="text-gray-200"><code>@ConfigurationProperties(prefix = "custom.service")
public class CustomServiceProperties {

    private String url;
    private int timeout;
    private boolean enabled;

    // Getter 和 Setter 方法
    public String getUrl() { return url; }
    public void setUrl(String url) { this.url = url; }
    public int getTimeout() { return timeout; }
    public void setTimeout(int timeout) { this.timeout = timeout; }
    public boolean isEnabled() { return enabled; }
    public void setEnabled(boolean enabled) { this.enabled = enabled; }
}</code></pre>
                    </div>
                </div>
                <div>
                    <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">配置文件示例</h3>
                    <div class="code-block mb-4">
                        <span class="lang">YAML</span>
                        <pre class="text-gray-200"><code>custom:
  service:
    url: "https://api.demo.com"
    timeout: 5000
    enabled: true</code></pre>
                    </div>
                    <div class="code-block">
                        <span class="lang">Properties</span>
                        <pre class="text-gray-200"><code>custom.service.url=https://api.demo.com
custom.service.timeout=5000
custom.service.enabled=true</code></pre>
                    </div>
                </div>
            </div>

            <div class="card bg-white p-6">
                <h3 class="heading-font text-xl font-semibold mb-4 text-blue-600">高级配置</h3>
                <div class="grid md:grid-cols-2 gap-6">
                    <div>
                        <h4 class="font-semibold mb-2 text-gray-800">校验规则</h4>
                        <div class="code-block">
                            <span class="lang">Java</span>
                            <pre class="text-gray-200"><code>@ConfigurationProperties(prefix = "custom.service")
public class CustomServiceProperties {

    @NotNull
    private String url;

    @Min(1000)
    private int timeout;
    
    // getters and setters
}</code></pre>
                        </div>
                    </div>
                    <div>
                        <h4 class="font-semibold mb-2 text-gray-800">复杂类型</h4>
                        <div class="code-block">
                            <span class="lang">Java</span>
                            <pre class="text-gray-200"><code>@ConfigurationProperties(prefix = "custom.service")
public class CustomServiceProperties {

    private List&lt;String&gt; servers;
    private Map&lt;String, String&gt; credentials;
    
    // getters and setters
}</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Visualization -->
        <section id="demo" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="section-icon">
                    <i class="fas fa-project-diagram text-xl"></i>
                </div>
                <h2 class="heading-font text-3xl font-bold">Starter工作机制可视化</h2>
            </div>
            
            <div class="card bg-white p-6">
                <div class="mermaid">
                    graph TD
                        A[Spring Boot应用启动] --> B[扫描META-INF/spring.factories]
                        B --> C[加载EnableAutoConfiguration配置]
                        C --> D[实例化自动配置类]
                        D --> E[处理@Conditional条件]
                        E -->|条件满足| F[注册Bean到Spring容器]
                        E -->|条件不满足| G[跳过配置]
                        F --> H[应用使用自动配置的Bean]
                </div>
            </div>
        </section>

        <!-- Summary -->
        <section class="mb-20">
            <div class="card bg-blue-50 border border-blue-100 p-8">
                <div class="flex items-start">
                    <div class="bg-blue-100 text-blue-600 rounded-full p-3 mr-4">
                        <i class="fas fa-lightbulb text-xl"></i>
                    </div>
                    <div>
                        <h3 class="heading-font text-2xl font-bold mb-4 text-blue-700">关键要点总结</h3>
                        <ul class="text-gray-700 space-y-3">
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mr-2 mt-1"></i>
                                <span>自定义Starter是Spring Boot模块化开发的核心机制，可以封装通用功能实现复用</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mr-2 mt-1"></i>
                                <span>自动配置类使用<code class="bg-blue-100 px-1 py-0.5 rounded text-blue-700">@Configuration</code>和条件注解实现按需装配</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mr-2 mt-1"></i>
                                <span><code class="bg-blue-100 px-1 py-0.5 rounded text-blue-700">spring.factories</code>文件声明自动配置类，是Starter的关键配置</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mr-2 mt-1"></i>
                                <span>配置属性类通过<code class="bg-blue-100 px-1 py-0.5 rounded text-blue-700">@ConfigurationProperties</code>实现外部化配置</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mr-2 mt-1"></i>
                                <span>合理的条件判断和懒加载策略可以优化Starter的性能</span>
                            </li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-12">
        <div class="container mx-auto px-6 max-w-5xl">
            <div class="flex flex-col items-center">
                <h3 class="heading-font text-xl font-semibold mb-2 text-white">技术小馆</h3>
                <a href="http://www.yuque.com/jtostring" class="text-blue-400 hover:text-blue-300 transition">http://www.yuque.com/jtostring</a>
                <div class="flex space-x-4 mt-4">
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-github"></i></a>
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-twitter"></i></a>
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-linkedin"></i></a>
                </div>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```